package com.dctp.common.utils;

/**
 * 字符串处理工具类
 */
public final class StringUtil {

    private StringUtil() {
        // 私有构造防止实例化
    }

    // region 基础判断方法
    
    /**
     * 判断字符串是否为null或空字符串
     */
    public static boolean isEmpty(CharSequence cs) {
        return cs == null || cs.length() == 0;
    }

    /**
     * 判断字符串是否不为空
     */
    public static boolean isNotEmpty(CharSequence cs) {
        return !isEmpty(cs);
    }

    /**
     * 判断字符串是否为空（包含空白字符）
     * ""、"  " 均返回true
     */
    public static boolean isBlank(CharSequence cs) {
        if (cs == null) return true;
        return cs.toString().trim().length() == 0;
    }

    /**
     * 判断字符串是否非空（包含非空白字符）
     */
    public static boolean isNotBlank(CharSequence cs) {
        return !isBlank(cs);
    }

    // endregion

    // region 字符串处理
    
    /**
     * 去除首尾空白字符（支持全角空格）
     */
    public static String trim(String str) {
        return str == null ? "" : str.replaceAll("^[\\s\\u3000]+|[\\s\\u3000]+$", "");
    }

    /**
     * 安全截取子字符串
     * @param str 原始字符串
     * @param start 起始索引（包含）
     * @param end 结束索引（不包含）
     */
    public static String substring(String str, int start, int end) {
        if (str == null) return "";
        
        int length = str.length();
        if (start < 0) start = 0;
        if (end > length) end = length;
        
        return start > end ? "" : str.substring(start, end);
    }

    /**
     * 截取左侧指定长度字符串
     */
    public static String left(String str, int len) {
        if (str == null) return "";
        return str.substring(0, Math.min(len, str.length()));
    }

    /**
     * 截取右侧指定长度字符串
     */
    public static String right(String str, int len) {
        if (str == null) return "";
        return str.substring(Math.max(0, str.length() - len));
    }

    /**
     * 反转字符串
     */
    public static String reverse(String str) {
        if (str == null) return "";
        return new StringBuilder(str).reverse().toString();
    }

    // endregion

    // region 格式转换
    
    /**
     * 首字母大写
     */
    public static String capitalize(String str) {
        if (isEmpty(str)) return str;
        return Character.toUpperCase(str.charAt(0)) + str.substring(1);
    }

    /**
     * 首字母小写
     */
    public static String uncapitalize(String str) {
        if (isEmpty(str)) return str;
        return Character.toLowerCase(str.charAt(0)) + str.substring(1);
    }

    /**
     * 下划线转驼峰命名（user_name -> userName）
     */
    public static String toCamelCase(String str) {
        if (isEmpty(str)) return str;
        
        String[] parts = str.split("_");
        StringBuilder sb = new StringBuilder(parts[0]);
        for (int i = 1; i < parts.length; i++) {
            sb.append(capitalize(parts[i]));
        }
        return sb.toString();
    }

    /**
     * 驼峰转下划线命名（userName -> user_name）
     */
    public static String toUnderlineCase(String str) {
        if (isEmpty(str)) return str;
        
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (Character.isUpperCase(c)) {
                sb.append('_').append(Character.toLowerCase(c));
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * 转换为kebab-case格式（userName -> user-name）
     */
    public static String toKebabCase(String str) {
        if (isEmpty(str)) return str;
        return toUnderlineCase(str).replace('_', '-');
    }

    // endregion

    // region 其他工具方法
    
    /**
     * 判断是否以指定前缀开头（忽略大小写）
     */
    public static boolean startsWithIgnoreCase(String str, String prefix) {
        if (str == null || prefix == null) return false;
        return str.regionMatches(true, 0, prefix, 0, prefix.length());
    }

    /**
     * 判断是否以指定后缀结尾（忽略大小写）
     */
    public static boolean endsWithIgnoreCase(String str, String suffix) {
        if (str == null || suffix == null) return false;
        int suffixLength = suffix.length();
        return str.regionMatches(true, str.length() - suffixLength, suffix, 0, suffixLength);
    }

    /**
     * 删除所有空白字符
     */
    public static String deleteWhitespace(String str) {
        if (isEmpty(str)) return str;
        return str.replaceAll("\\s+", "");
    }

    /**
     * 统计子字符串出现次数
     */
    public static int countMatches(String str, String sub) {
        if (isEmpty(str) || isEmpty(sub)) return 0;
        int count = 0;
        int idx = 0;
        while ((idx = str.indexOf(sub, idx)) != -1) {
            count++;
            idx += sub.length();
        }
        return count;
    }

    /**
     * 生成重复字符串
     */
    public static String repeat(String str, int repeat) {
        if (str == null || repeat <= 0) return "";
        return String.valueOf(str).repeat(repeat);
    }

    // endregion


    /**
     * 替换字符串中间部分为指定字符（自动居中替换）
     * @param str         原字符串
     * @param replaceLen  需要替换的长度
     * @param maskChar    替换字符（如 '*'）
     * @return 替换后的字符串，若输入无效则返回原字符串
     */
    public static String maskMiddle(String str, int replaceLen, char maskChar) {
        if (str == null || str.isEmpty() || replaceLen <= 0) {
            return str;
        }

        int totalLen = str.length();
        // 计算居中替换的起始位置
        int start = (totalLen - replaceLen) / 2;
        start = Math.max(0, start);  // 确保起始位置不越界
        int end = Math.min(start + replaceLen, totalLen);

        return doMask(str, start, end, maskChar);
    }

    /**
     * 替换字符串中间部分为指定字符（自定义起始位置）
     * @param str         原字符串
     * @param start       替换起始位置（包含）
     * @param end         替换结束位置（不包含）
     * @param maskChar    替换字符
     * @return 替换后的字符串，若输入无效则返回原字符串
     */
    public static String maskMiddle(String str, int start, int end, char maskChar) {
        if (str == null || str.isEmpty() || start < 0 || end <= start) {
            return str;
        }
        // 确保不越界
        start = Math.min(start, str.length());
        end = Math.min(end, str.length());
        return doMask(str, start, end, maskChar);
    }


    // 通用替换逻辑
    private static String doMask(String str, int start, int end, char maskChar) {
        if (start >= end) return str;

        String prefix = str.substring(0, start);
        String suffix = str.substring(end);
        String mask = String.valueOf(maskChar).repeat(end - start);
        return prefix + mask + suffix;
    }

    public static void main(String[] args) {

        System.out.println(maskMiddle("695801662@qq.com",4,'*'));
    }
}